package com.springboot.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.springboot.common.Result;
import com.springboot.entity.Order;
import com.springboot.entity.OrderItem;
import com.springboot.entity.Product;
import com.springboot.entity.ProductSku;
import com.springboot.mapper.OrderMapper;
import com.springboot.mapper.ProductSpecColorMapper;
import com.springboot.mapper.ProductSpecSizeMapper;
import com.springboot.service.IOrderItemService;
import com.springboot.service.IOrderService;
import com.springboot.service.IProductService;
import com.springboot.service.IProductSkuService;
import com.springboot.utils.IntegerUtils;
import com.springboot.vo.OrderListVO;
import com.springboot.vo.OrderListItemVO;
import com.springboot.vo.OrderVO;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

/**
 * <p>
 * 订单表 服务实现类
 * </p>
 *
 * @author zjb
 * @since 2025-10-30
 */
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    @Resource
    private OrderMapper orderMapper;

    @Resource
    private IOrderItemService orderItemService;
    
    @Resource
    private IProductService productService;
    
    @Resource
    private IProductSkuService productSkuService;
    
    @Resource
    private ProductSpecColorMapper productSpecColorMapper;

    @Resource
    private ProductSpecSizeMapper productSpecSizeMapper;

    /**
     * 创建订单
     *
     * @param order 订单信息
     * @param orderItems 订单明细列表
     * @return 创建结果
     */
    @Override
    @Transactional
    public Result createOrder(Order order, List<OrderItem> orderItems) {
        // 参数校验
        if (order.getUserId() == null) {
            return Result.error("用户ID不能为空");
        }

        if (order.getAddressId() == null) {
            return Result.error("收货地址不能为空");
        }

        if (CollectionUtils.isEmpty(orderItems)) {
            return Result.error("订单明细不能为空");
        }

        // 生成订单号（时间戳+随机数）
        if (order.getOrderId() == null || order.getOrderId().isEmpty()) {
            String orderId = System.currentTimeMillis() + UUID.randomUUID().toString().replace("-", "").substring(0, 8);
            order.setOrderId(orderId);
        }

        // 计算订单总金额并验证订单明细
        BigDecimal totalAmount = BigDecimal.ZERO;
        for (OrderItem item : orderItems) {
            // 验证商品是否存在
            Product product = productService.getById(item.getProductId());
            if (product == null) {
                return Result.error("商品不存在，商品ID: " + item.getProductId());
            }

            BigDecimal price;
            String productName = product.getProductName();

            // 如果有SKU，则从SKU获取价格和规格信息
            if (item.getSkuId() != null) {
                ProductSku sku = productSkuService.getById(item.getSkuId());
                if (sku == null) {
                    return Result.error("商品SKU不存在，SKU ID: " + item.getSkuId());
                }
                
                if (!sku.getProductId().equals(item.getProductId())) {
                    return Result.error("商品与SKU不匹配");
                }
                
                price = sku.getPrice();

                // SKU中不包含商品名称，继续使用商品的名称
            } else {
                // 没有SKU则从商品获取价格
                price = product.getDefaultPrice();
            }

            // 设置订单明细信息
            item.setPrice(price);
            item.setProductName(productName);
            
            // 计算小计金额
            BigDecimal subtotal = price.multiply(new BigDecimal(item.getQuantity()));
            item.setTotalPrice(subtotal);
            
            // 累加到订单总金额
            totalAmount = totalAmount.add(subtotal);
        }

        // 设置订单总金额（如果前端未传递）
        if (order.getTotalAmount() == null) {
            order.setTotalAmount(totalAmount);
            order.setPayAmount(totalAmount); // 默认实付金额等于总金额
        }

        // 验证金额是否匹配
        if (order.getTotalAmount().compareTo(totalAmount) != 0) {
            return Result.error("订单总金额计算有误");
        }

        // 设置订单状态
        order.setOrderStatus(0); // 待付款
        order.setPayStatus(0);   // 未支付
        order.setCreateTime(LocalDateTime.now());
        order.setUpdateTime(LocalDateTime.now());

        // 保存订单
        if (!save(order)) {
            return Result.error("创建订单失败");
        }

        // 保存订单明细（订单保存后才能获取到orderId）
        if (!CollectionUtils.isEmpty(orderItems)) {
            for (OrderItem item : orderItems) {
                item.setOrderId(order.getOrderId()); // 此时orderId已经生成
                item.setCreateTime(LocalDateTime.now());
            }
            if (!orderItemService.saveBatch(orderItems)) {
                throw new RuntimeException("保存订单明细失败");
            }
        }

        return Result.success(order.getOrderId(), "订单创建成功");
    }

    /**
     * 根据用户ID获取订单列表（分页）
     *
     * @param userId 用户ID
     * @param pageNum 页码
     * @param pageSize 每页数量
     * @return 订单列表
     */
    @Override
    public Result getOrdersByUserId(Integer userId, Integer pageNum, Integer pageSize) {
        if (IntegerUtils.isEmptyOrZero(userId)) {
            return Result.error("用户ID不能为空");
        }

        // 处理分页参数
        if (pageNum == null || pageNum <= 0) {
            pageNum = 1;
        }
        
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
        }

        // 创建分页对象
        IPage<OrderListVO> page = new Page<>(pageNum, pageSize);
        
        // 执行分页查询
        IPage<OrderListVO> resultPage = orderMapper.selectOrdersByUserId(page, userId);
        
//        // 补充订单项信息
//        resultPage.getRecords().forEach(orderListVO -> {
//            List<OrderListItemVO> orderItems = orderMapper.selectOrderItemsByOrderId(orderListVO.getOrderId());
//            orderListVO.setOrderItems(orderItems);
//        });

        return Result.success(resultPage, "查询成功");
    }

    /**
     * 根据订单号获取订单详情
     *
     * @param orderId 订单号
     * @param userId  用户ID（用于权限校验）
     * @return 订单详情
     */
    @Override
    public Result getOrderByOrderId(String orderId, Integer userId) {
        if (orderId == null || orderId.isEmpty()) {
            return Result.error("订单号不能为空");
        }

        if (IntegerUtils.isEmptyOrZero(userId)) {
            return Result.error("用户ID不能为空");
        }

        OrderVO order = orderMapper.selectOrderByOrderId(orderId);

        if (order == null) {
            return Result.error("订单不存在");
        }

        // 权限校验：只能查看自己的订单
        if (!userId.equals(order.getUserId())) {
            return Result.error("无权限查看该订单");
        }

        // 直接返回订单项中的原始 spec_values（格式：colorId:sizeId）
        if (order.getOrderItems() != null) {
            order.getOrderItems().forEach(item -> {
                // 不再进行规格名称转换
            });
        }

        return Result.success(order, "查询成功");
    }

    /**
     * 取消订单
     *
     * @param orderId 订单号
     * @param userId  用户ID（用于权限校验）
     * @return 取消结果
     */
    @Override
    public Result cancelOrder(String orderId, Integer userId) {
        if (orderId == null || orderId.isEmpty()) {
            return Result.error("订单号不能为空");
        }

        if (IntegerUtils.isEmptyOrZero(userId)) {
            return Result.error("用户ID不能为空");
        }

        Order order = getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderId, orderId));

        if (order == null) {
            return Result.error("订单不存在");
        }

        // 权限校验
        if (!userId.equals(order.getUserId())) {
            return Result.error("无权限操作该订单");
        }

        // 状态校验：只有待付款或待发货的订单才能取消
        if (order.getOrderStatus() != 0 && order.getOrderStatus() != 1) {
            return Result.error("当前订单状态无法取消");
        }

        // 更新订单状态
        order.setOrderStatus(4); // 已取消
        order.setUpdateTime(LocalDateTime.now());

        if (updateById(order)) {
            return Result.success("订单取消成功");
        } else {
            return Result.error("订单取消失败");
        }
    }

    /**
     * 确认收货
     *
     * @param orderId 订单号
     * @param userId  用户ID（用于权限校验）
     * @return 确认结果
     */
    @Override
    public Result confirmReceipt(String orderId, Integer userId) {
        if (orderId == null || orderId.isEmpty()) {
            return Result.error("订单号不能为空");
        }

        if (IntegerUtils.isEmptyOrZero(userId)) {
            return Result.error("用户ID不能为空");
        }

        Order order = getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderId, orderId));

        if (order == null) {
            return Result.error("订单不存在");
        }

        // 权限校验
        if (!userId.equals(order.getUserId())) {
            return Result.error("无权限操作该订单");
        }

        // 状态校验：只有待收货的订单才能确认收货
        if (order.getOrderStatus() != 2) {
            return Result.error("当前订单状态无法确认收货");
        }

        // 更新订单状态
        order.setOrderStatus(3); // 已完成
        order.setUpdateTime(LocalDateTime.now());

        if (updateById(order)) {
            return Result.success("确认收货成功");
        } else {
            return Result.error("确认收货失败");
        }
    }

    /**
     * 删除订单（仅限已取消的订单）
     *
     * @param orderId 订单号
     * @param userId  用户ID（用于权限校验）
     * @return 删除结果
     */
    @Override
    @Transactional
    public Result deleteOrder(String orderId, Integer userId) {
        if (orderId == null || orderId.isEmpty()) {
            return Result.error("订单号不能为空");
        }

        if (IntegerUtils.isEmptyOrZero(userId)) {
            return Result.error("用户ID不能为空");
        }

        Order order = getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderId, orderId));

        if (order == null) {
            return Result.error("订单不存在");
        }

        // 权限校验
        if (!userId.equals(order.getUserId())) {
            return Result.error("无权限操作该订单");
        }

        // 状态校验：只有已取消的订单才能删除
        if (order.getOrderStatus() != 4) {
            return Result.error("只有已取消的订单才能删除");
        }

        // 删除订单明细
        LambdaQueryWrapper<OrderItem> itemWrapper = new LambdaQueryWrapper<>();
        itemWrapper.eq(OrderItem::getOrderId, orderId);
        if (!orderItemService.remove(itemWrapper)) {
            return Result.error("删除订单明细失败");
        }

        // 删除订单
        if (removeById(orderId)) {
            return Result.success("订单删除成功");
        } else {
            return Result.error("订单删除失败");
        }
    }
}